Dec29, 2025

Como integrar DrissionPage com CapSolver para resolução de CAPTCHA sem interrupções

Adélia Cruz

Neural Network Developer

1. Introdução

A automação web tornou-se essencial para coleta de dados, testes e várias operações empresariais. No entanto, os sites modernos implementam medidas anti-bot sofisticadas e CAPTCHAs que podem interromper até mesmo os scripts de automação mais bem elaborados.

A combinação do DrissionPage e do CapSolver oferece uma solução poderosa para esse desafio:

DrissionPage: Uma ferramenta de automação web baseada em Python que controla navegadores Chromium sem exigir WebDriver, combinando automação de navegador com solicitações HTTP
CapSolver: Um serviço de resolução de CAPTCHA baseado em IA que lida com Cloudflare Turnstile, reCAPTCHA e mais

Juntos, essas ferramentas permitem automação web sem interrupções que evita a detecção de WebDriver e desafios de CAPTCHA.

1.1. Objetivos da Integração

Este guia o ajudará a atingir três objetivos principais:

Evitar a Detecção de WebDriver - Use o controle nativo do navegador do DrissionPage sem assinaturas de Selenium/WebDriver
Resolver CAPTCHAs Automaticamente - Integre a API do CapSolver para lidar com desafios de CAPTCHA sem intervenção manual
Manter Comportamento Humano - Combine cadeias de ações com resolução inteligente de CAPTCHA

2. O que é DrissionPage?

DrissionPage é uma ferramenta de automação web baseada em Python que combina controle de navegador com capacidades de solicitação HTTP. Ao contrário do Selenium, ele usa um kernel desenvolvido por conta própria que não depende de WebDriver, tornando-o mais difícil de detectar.

2.1. Principais Funcionalidades

Nenhum WebDriver Necessário - Controla navegadores Chromium nativamente sem o chromedriver
Operação em Modo Duplo - Combine automação de navegador (modo d) com solicitações HTTP (modo s)
Localização de Elementos Simplificada - Sintaxe intuitiva para encontrar elementos
Navegação entre iframes - Localize elementos em iframes sem precisar trocar
Suporte a Múltiplas Abas - Operar várias abas simultaneamente
Cadeias de Ações - Encadear ações de mouse e teclado
Esperas Integradas - Mecanismos de retry automáticos para redes instáveis

2.2. Instalação

bash Copy

# Instale o DrissionPage
pip install DrissionPage

# Instale a biblioteca requests para a API do CapSolver
pip install requests

2.3. Uso Básico

python Copy

from DrissionPage import ChromiumPage

# Crie uma instância do navegador
page = ChromiumPage()

# Navegue até a URL
page.get('https://wikipedia.org')

# Encontre e interaja com elementos
page('#search-input').input('Hello World')
page('#submit-btn').click()

3. O que é CapSolver?

CapSolver é um serviço de resolução automática de CAPTCHA baseado em IA que suporta uma ampla gama de tipos de CAPTCHA. Ele fornece uma API simples que permite enviar desafios de CAPTCHA e receber soluções em segundos.

3.1. Tipos de CAPTCHA Suportados

Cloudflare Turnstile - O desafio anti-bot mais comum atualmente
Cloudflare Challenge
reCAPTCHA v2 - Variantes baseadas em imagem e invisíveis
reCAPTCHA v3 - Verificação baseada em pontuação
AWS WAF - CAPTCHA da Amazon Web Services
E muitos mais...

3.2. Começando com o CapSolver

Registre-se em capsolver.com
Adicione fundos à sua conta
Obtenha sua chave de API no painel de controle

3.3. Pontos de Extremidade da API

Servidor A: https://api.capsolver.com
Servidor B: https://api-stable.capsolver.com

4. Desafios Pré-Integração

Antes de combinar o DrissionPage com o CapSolver, a automação web enfrentava vários problemas:

Desafio	Impacto
Detecção de WebDriver	Scripts do Selenium bloqueados imediatamente
Desafios de CAPTCHA	Resolução manual necessária, quebra a automação
Complexidade de iframe	Difícil interagir com conteúdo aninhado
Operações em múltiplas abas	Requer lógica complexa de troca de aba

A integração DrissionPage + CapSolver resolve todos esses desafios em um único fluxo de trabalho.

5. Métodos de Integração

5.1. Integração via API (Recomendado)

O método de integração via API oferece controle total sobre o processo de resolução de CAPTCHA e funciona com qualquer tipo de CAPTCHA.

5.1.1. Requisitos de Configuração

bash Copy

pip install DrissionPage requests

5.1.2. Padrão de Integração Básico

python Copy

import time
import requests
from DrissionPage import ChromiumPage

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def create_task(task_payload: dict) -> str:
    """Crie uma tarefa de resolução de CAPTCHA e retorne o ID da tarefa."""
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": task_payload
        }
    )
    result = response.json()
    if result.get("errorId") != 0:
        raise Exception(f"Erro do CapSolver: {result.get('errorDescription')}")
    return result["taskId"]


def get_task_result(task_id: str, max_attempts: int = 120) -> dict:
    """Verifique o resultado da tarefa até que seja resolvido ou expire o tempo limite."""
    for _ in range(max_attempts):
        response = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        )
        result = response.json()

        if result.get("status") == "ready":
            return result["solution"]
        elif result.get("status") == "failed":
            raise Exception(f"Tarefa falhou: {result.get('errorDescription')}")

        time.sleep(1)

    raise TimeoutError("Tempo esgotado para resolução de CAPTCHA")


def solve_captcha(task_payload: dict) -> dict:
    """Fluxo completo de resolução de CAPTCHA."""
    task_id = create_task(task_payload)
    return get_task_result(task_id)

5.2. Extensão do Navegador

Você também pode usar a extensão CapSolver com o DrissionPage para uma abordagem mais passiva.

5.2.1. Etapas de Instalação

Baixe a extensão CapSolver em capsolver.com/en/extension
Extraia os arquivos da extensão
Configure sua chave de API no arquivo config.js da extensão:

javascript Copy

// No diretório da extensão, edite: assets/config.js
var defined = {
    apiKey: "SUA_CHAVE_DE_API_DO_CAPSOLVER",  // Substitua pela sua chave de API real
    enabledForBlacklistControl: false,
    blackUrlList: [],
    enabledForRecaptcha: true,
    enabledForRecaptchaV3: true,
    enabledForTurnstile: true,
    // ... outras configurações
}

Carregue-a no DrissionPage:

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.add_extension('/caminho/para/a/extensão/capsolver')

page = ChromiumPage(co)
# A extensão detectará e resolverá CAPTCHAs automaticamente

Nota: A extensão deve ter uma chave de API válida configurada antes de poder resolver CAPTCHAs automaticamente.

6. Exemplos de Código

6.1. Resolvendo Cloudflare Turnstile

Cloudflare Turnstile é um dos desafios de CAPTCHA mais comuns. Aqui está como resolvê-lo:

python Copy

import time
import requests
from DrissionPage import ChromiumPage

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_turnstile(site_key: str, page_url: str) -> str:
    """Resolva o Cloudflare Turnstile e retorne o token."""
    # Crie a tarefa
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "AntiTurnstileTaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Erro: {result.get('errorDescription')}")

    task_id = result["taskId"]

    # Verifique o resultado
    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["token"]
        elif result.get("status") == "failed":
            raise Exception(f"Falha: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    target_url = "https://seu-site-alvo.com"
    turnstile_site_key = "0x4XXXXXXXXXXXXXXXXX"  # Encontre isso no código da página

    # Crie instância do navegador
    page = ChromiumPage()
    page.get(target_url)

    # Aguarde o Turnstile carregar
    page.wait.ele_displayed('input[name="cf-turnstile-response"]', timeout=10)

    # Resolva o CAPTCHA
    token = solve_turnstile(turnstile_site_key, target_url)
    print(f"Obtido token do Turnstile: {token[:50]}...")

    # Injetar o token usando JavaScript
    page.run_js(f'''
        document.querySelector('input[name="cf-turnstile-response"]').value = "{token}";

        // Também dispare o callback se presente
        const callback = document.querySelector('[data-callback]');
        if (callback) {{
            const callbackName = callback.getAttribute('data-callback');
            if (window[callbackName]) {{
                window[callbackName]('{token}');
            }}
        }}
    ''')

    # Submeta o formulário
    page('button[type="submit"]').click()
    page.wait.load_start()

    print("Turnstile bypassado com sucesso!")


if __name__ == "__main__":
    main()

6.2. Resolvendo reCAPTCHA v2 (Detecção Automática da Chave do Site)

Este exemplo detecta automaticamente a chave do site - nenhuma configuração manual é necessária:

python Copy

import time
import requests
from DrissionPage import ChromiumPage, ChromiumOptions

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_recaptcha_v2(site_key: str, page_url: str) -> str:
    """Resolva a reCAPTCHA v2 e retorne o token."""
    # Crie a tarefa
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV2TaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Erro: {result.get('errorDescription')}")

    task_id = result["taskId"]
    print(f"Tarefa criada: {task_id}")

    # Verifique o resultado
    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
        elif result.get("status") == "failed":
            raise Exception(f"Falha: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    # Basta fornecer a URL - a chave do site será detectada automaticamente
    target_url = "https://www.google.com/recaptcha/api2/demo"

    # Configure o navegador
    co = ChromiumOptions()
    co.set_argument('--disable-blink-features=AutomationControlled')

    print("Iniciando o navegador...")
    page = ChromiumPage(co)

    try:
        page.get(target_url)
        time.sleep(2)

        # Detectar automaticamente a chave do site da página
        recaptcha_div = page('.g-recaptcha')
        if not recaptcha_div:
            print("Nenhuma reCAPTCHA encontrada na página!")
            return

        site_key = recaptcha_div.attr('data-sitekey')
        print(f"Chave do site detectada automaticamente: {site_key}")

        # Resolva o CAPTCHA
        print("Resolvendo reCAPTCHA v2...")
        token = solve_recaptcha_v2(site_key, target_url)
        print(f"Obtido token: {token[:50]}...")

        # Injetar o token
        page.run_js(f'''
            var responseField = document.getElementById('g-recaptcha-response');
            responseField.style.display = 'block';
            responseField.value = '{token}';
        ''')
        print("Token injetado!")

        # Submeta o formulário
        submit_btn = page('#recaptcha-demo-submit') or page('input[type="submit"]') or page('button[type="submit"]')
        if submit_btn:
            submit_btn.click()
            time.sleep(3)
            print("Formulário enviado!")

        print(f"URL atual: {page.url}")
        print("SUCESSO!")

    finally:
        page.quit()


if __name__ == "__main__":
    main()

Teste você mesmo:

bash Copy

python recaptcha_demo.py

Isso abrirá a página de demonstração da reCAPTCHA do Google, detectará automaticamente a chave do site, resolverá o CAPTCHA e enviará o formulário.

6.3. Resolvendo reCAPTCHA v3

A reCAPTCHA v3 é baseada em pontuação e não exige interação do usuário. Você precisa especificar o parâmetro de ação.

python Copy

import time
import requests
from DrissionPage import ChromiumPage, ChromiumOptions

CAPSOLVER_API_KEY = "SUA_CHAVE_DE_API"
CAPSOLVER_API = "https://api.capsolver.com"


def solve_recaptcha_v3(
    site_key: str,
    page_url: str,
    action: str = "verify",
    min_score: float = 0.7
) -> str:
    """Resolva a reCAPTCHA v3 com ação especificada e pontuação mínima."""
    response = requests.post(
        f"{CAPSOLVER_API}/createTask",
        json={
            "clientKey": CAPSOLVER_API_KEY,
            "task": {
                "type": "ReCaptchaV3TaskProxyLess",
                "websiteURL": page_url,
                "websiteKey": site_key,
                "pageAction": action,
                "minScore": min_score
            }
        }
    )
    result = response.json()

    if result.get("errorId") != 0:
        raise Exception(f"Erro: {result.get('errorDescription')}")

    task_id = result["taskId"]

    while True:
        result = requests.post(
            f"{CAPSOLVER_API}/getTaskResult",
            json={
                "clientKey": CAPSOLVER_API_KEY,
                "taskId": task_id
            }
        ).json()

        if result.get("status") == "ready":
            return result["solution"]["gRecaptchaResponse"]
        elif result.get("status") == "failed":
            raise Exception(f"Falha: {result.get('errorDescription')}")

        time.sleep(1)


def main():
    target_url = "https://seu-site-alvo.com"
    recaptcha_v3_key = "6LcXXXXXXXXXXXXXXXXXXXXXXXXX"

    # Configurar navegador em modo headless para v3
    co = ChromiumOptions()
    co.headless()

    page = ChromiumPage(co)
    page.get(target_url)

    # Resolva a reCAPTCHA v3 com ação "search"
    print("Resolvendo reCAPTCHA v3...")
    token = solve_recaptcha_v3(
        recaptcha_v3_key,
        target_url,
        action="search",
        min_score=0.9  # Solicite uma pontuação alta
    )

    # Execute o callback com o token
    page.run_js(f'''
        // Se houver uma função de callback, chame-a com o token
        if (typeof onRecaptchaSuccess === 'function') {{
            onRecaptchaSuccess('{token}');
}}
        // Ou defina o valor do campo oculto
        var responseField = document.querySelector('[name="g-recaptcha-response"]');
        if (responseField) {{
            responseField.value = '{token}';
        }}
    ''')

    print("reCAPTCHA v3 contornado!")


if __name__ == "__main__":
    main()

6.4. Usando Cadeias de Ações para Comportamento Humano

As cadeias de ações do DrissionPage fornecem movimentos de mouse e interações de teclado mais naturais:

python Copy

import time
import random
from DrissionPage import ChromiumPage
from DrissionPage.common import Keys, Actions

def atraso_humano():
    """Atraso aleatório para imitar comportamento humano."""
    time.sleep(random.uniform(0.5, 1.5))

def main():
    page = ChromiumPage()
    page.get('https://seu-site-alvo.com/form')

    # Use cadeias de ações para interações com comportamento humano
    ac = Actions(page)

    # Mova-se para o campo de entrada naturalmente, depois clique e digite
    ac.move_to('input[name="email"]').click()
    atraso_humano()

    # Digite lentamente como um humano
    for char in "user@email.com":
        ac.type(char)
        time.sleep(random.uniform(0.05, 0.15))

    atraso_humano()

    # Mova-se para o campo de senha
    ac.move_to('input[name="password"]').click()
    atraso_humano()

    # Digite a senha
    page('input[name="password"]').input("mypassword123")

    # Após resolver o CAPTCHA, clique em enviar com movimento natural
    ac.move_to('button[type="submit"]')
    atraso_humano()
    ac.click()

if __name__ == "__main__":
    main()

7. Práticas Recomendadas

7.1. Configuração do Navegador

Configure o DrissionPage para parecer mais um navegador regular:

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.set_argument('--disable-blink-features=AutomationControlled')
co.set_argument('--no-sandbox')
co.set_user_agent('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36')

# Defina o tamanho da janela para uma resolução comum
co.set_argument('--window-size=1920,1080')

page = ChromiumPage(co)

7.2. Modo Incógnito e Headless

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.incognito()  # Use o modo incógnito
co.headless()   # Execute em modo headless (para CAPTCHAs v3)

page = ChromiumPage(co)

7.3. Limitação de Taxa

Evite disparar limites de taxa adicionando atrasos aleatórios:

python Copy

import random
import time

def atraso_humano(min_sec=1.0, max_sec=3.0):
    """Atraso aleatório para imitar comportamento humano."""
    time.sleep(random.uniform(min_sec, max_sec))

# Use entre ações
page('#button1').click()
atraso_humano()
page('#input1').input('texto')

7.4. Tratamento de Erros

Sempre implemente tratamento de erros adequado para resolução de CAPTCHA:

python Copy

def resolver_com_retentativa(payload_da_tarefa: dict, max_tentativas: int = 3) -> dict:
    """Resolva CAPTCHA com lógica de tentativa de novo."""
    for tentativa in range(max_tentativas):
        try:
            return resolver_captcha(payload_da_tarefa)
        except TimeoutError:
            if tentativa < max_tentativas - 1:
                print(f"Tempo esgotado, tentando novamente... ({tentativa + 1}/{max_tentativas})")
                time.sleep(5)
            else:
                raise
        except Exception as e:
            if "saldo" in str(e).lower():
                raise  # Não tente novamente erros de saldo
            if tentativa < max_tentativas - 1:
                time.sleep(2)
            else:
                raise

7.5. Suporte a Proxy

Use proxies com o DrissionPage para rotação de IP:

python Copy

from DrissionPage import ChromiumPage, ChromiumOptions

co = ChromiumOptions()
co.set_proxy('http://username:password@proxy.example.com:8080')

page = ChromiumPage(co)

8. Conclusão

A integração do DrissionPage e CapSolver cria uma ferramenta poderosa para automação web:

DrissionPage lida com automação de navegador sem assinaturas de detecção do WebDriver
CapSolver lida com CAPTCHAs com resolução por inteligência artificial
Juntos eles permitem automação sem interrupções que parecem totalmente humanas

Seja para construir web scrapers, sistemas de testes automatizados ou pipelines de coleta de dados, essa combinação fornece a confiabilidade e o disfarce que você precisa.

Bônus: Use o código DRISSION ao se inscrever no CapSolver para receber créditos bônus!

9. Perguntas Frequentes

9.1. Por que escolher o DrissionPage em vez do Selenium?

O DrissionPage não usa WebDriver, o que significa:

Não é necessário baixar/atualizar o chromedriver
Evita assinaturas comuns de detecção do WebDriver
API mais simples com espera integrada
Melhor desempenho e uso de recursos
Suporte nativo para localização de elementos em iframes

9.2. Quais tipos de CAPTCHA funcionam melhor com essa integração?

O CapSolver suporta todos os principais tipos de CAPTCHA. O Turnstile do Cloudflare e o reCAPTCHA v2/v3 têm as maiores taxas de sucesso. A integração funciona perfeitamente com qualquer CAPTCHA suportado pelo CapSolver.

9.3. Posso usar isso no modo headless?

Sim! O DrissionPage suporta modo headless. No modo headless, o reCAPTCHA v3 e CAPTCHAs baseados em token funcionam perfeitamente. Para CAPTCHAs v2 visíveis, o modo com interface gráfica pode oferecer melhores resultados.

9.4. Como encontrar a chave do site para um CAPTCHA?

Procure no código fonte da página por:

Turnstile: atributo data-sitekey ou elementos cf-turnstile
reCAPTCHA: atributo data-sitekey no div g-recaptcha

9.5. O que fazer se a resolução do CAPTCHA falhar?

Soluções comuns:

Verifique sua chave de API e saldo
Certifique-se de que a chave do site está correta
Confirme que a URL da página coincide com onde o CAPTCHA aparece
Para o v3, tente ajustar o parâmetro de ação e a pontuação mínima
Implemente lógica de tentativa de novo com atrasos

9.6. O DrissionPage pode lidar com DOM shadow?

Sim! O DrissionPage tem suporte integrado a elementos do DOM shadow por meio da classe ChromiumShadowElement.

Ver mais

web scrapingApr 22, 2026

Arquitetura de Web Scraping em Rust para Extração de Dados Escalável

Aprenda arquitetura de raspagem web escalável em Rust com reqwest, scraper, raspagem assíncrona, raspagem de navegador headless, rotação de proxies e tratamento de CAPTCHA compatível.

Adélia Cruz

web scrapingApr 08, 2026

Selenium vs Puppeteer para Resolução de CAPTCHA: Comparação de Desempenho e Caso de Uso

Compare o Selenium vs Puppeteer para resolver CAPTCHA. Descubra benchmarks de desempenho, notas de estabilidade e como integrar o CapSolver para o máximo de sucesso.